javascript常见手写代码

Author Avatar
高翔 3月 24, 2017

算法，深复制，事件代理。。。

全排列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function swap(arr,i,j) { 
    if(i!=j) {          
        var temp=arr[i]; 
        arr[i]=arr[j]; 
        arr[j]=temp; 
    } 
} 
var count=0; 
function show(arr) { 
    document.write("P<sub>"+ ++count+"</sub>: "+arr+"<br />"); 
} 
//此方法最主要是交换的思路
function perm(arr) {   
     (function fn(n) { //为第n个位置选择元素
        for(var i=n;i<arr.length;i++) { 
            swap(arr,i,n);
             if(n+1<arr.length-1) //根据下标a(b+1) 不是最后一项，判断数组中剩余的待全排列的元素是否大于1个
                 fn(n+1); //从第n+1个下标进行全排列
             else
                 show(arr); //显示一组结果
             swap(arr,i,n); 
         } 
     })(0); 
 } 
 perm(["e1","e2","e3",'e4']);

HASH表去重

1
2
3
4
5
6
7
8
9
10
11
12
13
Array.prototype.unique2 = function()
{
	var n = {},r=[]; //n为hash表，r为临时数组
	for(var i = 0; i < this.length; i++) //遍历当前数组
	{
		if (!n[this[i]]) //如果hash表中没有当前项
		{
			n[this[i]] = this[i]; //存入hash表
			r.push(this[i]); //把当前数组的当前项push到临时数组里面
		} else if(typeof(n[this[i]]) !== typeof(this[i])) { r.push(this[i])}//num和string不算重复:如'2'和2
	}
	return r;
}

快排

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//定义位置交换的方法
       function swap (arr, index1, index2) {
           var temp = arr[index1];
           arr[index1] = arr[index2];
           arr[index2] = temp;
       };
       //划分过程
       function partition (arr, left, right) {
           var pivot = arr[Math.floor((right + left) / 2)],  // 中轴的值。
                   i = left,
                   j = right;
           while (i <= j) {
                   // 先从左边开始，当遇到比中轴大的值停止向前
                   while (arr[i] < pivot) { 
                       i++;
                   }
                   while (arr[j] > pivot) {
                       j--;
                   }
                   //直到左边遇到>中值的，右边遇到<中指的，便交换
                   if (i <= j) {
                       swap(arr, i, j);
                       i++;
                       j--;
                   }
           }
           //返回左指针的位置
           return i;
       };
       //递归调用quick
       function quick (arr, left, right){
           var index;
           //主流程直到分割到数组长度为1时结束
           if (arr.length > 1) {
               index = partition(arr, left, right);
               //这里用if来将分割的左右两部分分别执行quick
               if (left < index - 1) {
                   quick(arr, left, index - 1);
               }
               if (index < right) {
                   quick(arr, index, right);
               }
            }
           return arr;  // 结束位置
       }

笔试输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var readline = require('readline');
rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var K = 1; // 输入K行
var inputs = [];
rl.on('line', function(data) {
    // 获取输入
    inputs.push(data.trim());
    if (K == inputs.length) { //
        // 处理
        var result = deal(inputs);
        // 输出结果
        console.log(result);
        // 清0
        inputs.length = 0;
    }
});

堆排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
//调整函数
function headAdjust(elements, pos, len){
  //将当前节点值进行保存
  var swap = elements[pos];
  //定位到当前节点的左边的子节点
  var child = pos * 2 + 1;
  //递归，直至没有子节点为止
  while(child < len){
    //如果当前节点有右边的子节点，并且右子节点较大的场合，采用右子节点
    //和当前节点进行比较
    if(child + 1 < len && elements[child] < elements[child + 1]){
      child += 1;
    }
    //比较当前节点和最大的子节点，小于则进行值交换，交换后将当前节点定位
    //于子节点上
    if(elements[pos] < elements[child]){
      elements[pos] = elements[child];
      pos = child;
      child = pos * 2 + 1;
    }
    else{console.log(elements); 
      break;
    }
    elements[pos] = swap;console.log(elements); 
 }
}
//构建堆
function buildHeap(elements){
  //从最后一个拥有子节点的节点开始，将该节点连同其子节点进行比较，
  //将最大的数交换与该节点,交换后，再依次向前节点进行相同交换处理，
  //直至构建出大顶堆（升序为大顶，降序为小顶）
  for(var i=elements.length/2; i>=0; i--){
    headAdjust(elements, i, elements.length);
  }
}
function sort(elements){
  //构建堆
  buildHeap(elements);
  //从数列的尾部开始进行调整
  for(var i=elements.length-1; i>0; i--){
    //堆顶永远是最大元素，故，将堆顶和尾部元素交换，将
    //最大元素保存于尾部，并且不参与后面的调整
    var swap = elements[i];
    elements[i] = elements[0];
    elements[0] = swap;
    //进行调整，将最大）元素调整至堆顶
    headAdjust(elements, 0, i);
  }
}

手写事件代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
function delegateEvent(interfaceEle, selector, type, fn) {
    if(interfaceEle.addEventListener){
    interfaceEle.addEventListener(type, eventfn);
    }else{
    interfaceEle.attachEvent("on"+type, eventfn);
    }
     
    function eventfn(e){
    var e = e || window.event;    
    var target = e.target || e.srcElement;
    if (matchSelector(target, selector)) {
            if(fn) {
                fn.call(target, e);
            }
        }
    }
}
/**
 * only support #id, tagName, .className
 * and it's simple single, no combination
 */
function matchSelector(ele, selector) {
    // if use id
    if (selector.charAt(0) === "#") {
        return ele.id === selector.slice(1);
    }
    // if use class
    if (selector.charAt(0) === ".") {
        return (" " + ele.className + " ").indexOf(" " + selector.slice(1) + " ") != -1;
    }
    // if use tagName
    return ele.tagName.toLowerCase() === selector.toLowerCase();
}
//调用
var odiv = document.getElementById("oDiv");
delegateEvent(odiv,"a","click",function(){
    alert("1");
})

手写深复制（兼容数组和对象)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
function clone(obj) {
    var copy;
    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) return obj;
    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }
    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = clone(obj[i]);
        }
        return copy;
    }
    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr]);
        }
        return copy;
    }
    throw new Error("Unable to copy obj! Its type isn't supported.");
}

待更新——完善注释

expand_less